package com.itheima.edu.info.manager.dao;


import com.itheima.edu.info.manager.domain.Student;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Properties;

public class OtherStudentDao implements BaseStudentDao {

    //创建一个集合容器
    private static ArrayList<Student> stus = new ArrayList<>();

    //添加静态static代码块
    static {

        load01();
        //  load02();
        //  load03();
        // load04();
        //  load05();

    }

    //库管的添加方法
    public boolean addStudent(Student stu) {
        //把学生对象装进集合
        stus.add(stu);
        //数据存档
        reSave01();
        //这个集合是装不满的，直接返回一个固定值真
        return true;
    }


    //库管的删除方法
    public void deleteStudentById(String delId) {
        //查找要删除的学生id在容器中的索引位置
        int index = getIndex(delId);
        //数组变为集合，可以直接用集合的remove方法达到删除效果
        stus.remove(index);
        //数据存档
        reSave01();
    }

    //库管的修改方法
    public void updateStudentById(String newStr) {
        //切割字符串创建学生对象
        String[] split = newStr.split(",");
        Student stu = new Student(split[0], split[1], split[2], split[3]);
        //获取修改对象的id对应的索引
        int index = getIndex(stu.getId());
        //将stu去覆盖该索引位置的旧对象，从而达到修改效果
        stus.set(index, stu);
        //数据存档
        reSave01();


    }


    //库管的库管的查看方法
    public Student[] findAllStudent() {
        //新建一个学生数组，长度和集合长度保持一致
        Student[] Students = new Student[stus.size()];
        //对集合容器中的数据进行排序
        Collections.sort(stus, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getId().compareTo(o2.getId());
            }
        });
        stus.toArray(Students);
        for (int i = 0; i < Students.length; i++) {
            Students[i] = stus.get(i);
        }
        return Students;
    }


    //根据学号查找对应的学生对象在集合容器中的索引位置
    public int getIndex(String id) {
        //1.先假设要查找的学号不存在，index先记录-1
        int index = -1;
        //遍历集合容器
        for (int i = 0; i < stus.size(); i++) {
            //2.1拿到每一个学生对象
            Student stu = stus.get(i);

            //2.2判断当前学生对象的学号在容器中不为空和要查找的学号是否相同
            if (stus != null && stu.getId().equals(id)) {
                //相同，则说明要查找的学号存在，则修改为当前学生对象的索引
                index = i;
                break;
            }
        }
        return index;
    }


    //字节输入流读取本地文件
    public static void load01() {

        try {
            //创建一个字节输入流对象，指定要读取的文件
            FileInputStream du = new FileInputStream("server\\stu.txt");
            //循环读，将文件中所有数据都读入内存
            byte[] bys = new byte[1024 * 1024];
            int len = du.read(bys);

            //基于读取到的键值数据封装对应的字符串
            String allStudentMsg = new String(bys, 0, len);

            //先通过换行符切割所有学生信息
            String[] allStudentMsgArray = allStudentMsg.split(System.lineSeparator());

            //遍历这个数组allStudentMsgArray，拿到每一个学生信息
            for (int i = 0; i < allStudentMsgArray.length; i++) {
                String stuStr = allStudentMsgArray[i];

                //再根据逗号,对单个学生信息进行切割
                String[] stuMsgArray = stuStr.split(",");

                //根据信息封装学生对象
                Student stu = new Student(stuMsgArray[0], stuMsgArray[1], stuMsgArray[2], stuMsgArray[3]);

                //将学生对象存入集合
                stus.add(stu);
            }
            du.close();
        } catch (Exception e) {
            System.out.println("读取本地内容异常可检查本地文件内容格式！");
        }

    }

    //字节缓冲输入流读取本地文件
    public static void load02() {

        try {
            //创建字节缓冲输入流读取本地文件内容
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("server\\stu.txt"));
            //循环读取内容到内存
            byte[] bys = new byte[1024 * 1024];
            int len = bis.read(bys);
            //把读取到的内容封装为字符串
            String s2 = new String(bys, 0, len);
            //把字符串切割成一行一条信息
            String[] StrSplit = s2.split(System.lineSeparator());
            //遍历每条信息再次切割成属性
            for (int i = 0; i < StrSplit.length; i++) {
                String StrStuMsg = StrSplit[i];
                String[] splitMsgArr = StrStuMsg.split(",");
                //把每条分好属性的信息封装为学生对象
                Student stu = new Student(splitMsgArr[0], splitMsgArr[1], splitMsgArr[2], splitMsgArr[3]);
                //把学生对象放入集合
                stus.add(stu);
            }
            bis.close();
        } catch (IOException e) {
            System.out.println("读取本地内容异常");
        }


    }

    //字符输入流读取本地文件
    public static void load03() {
        try {
            //读取本地文件
            FileReader fr = new FileReader("server\\stu.txt");
            //读进内存
            char[] chs = new char[1024];
            int ch = fr.read(chs);
            //把内存读取的内容转为字符串
            String s3 = new String(chs, 0, ch);
            //字符串换行
            String[] splitline = s3.split(System.lineSeparator());
            //每行遍历分割成属性
            for (int i = 0; i < splitline.length; i++) {
                String strHang = splitline[i];
                String[] splitSX = strHang.split(",");
                //封装为学生对象
                Student stu = new Student(splitSX[0], splitSX[1], splitSX[2], splitSX[3]);
                //把学生对象存入数组
                stus.add(stu);
            }
        } catch (IOException e) {
            System.out.println("加载文件发生异常");
        }
    }

    //字符缓冲输入流读取本地文件
    public static void load04() {
        try {
            //读取本地文件
            BufferedReader br = new BufferedReader(new FileReader("server\\stu.txt"));
            //字符串来接
            String str4;
            //while循环读取
            while ((str4 = br.readLine()) != null) {
                //切割属性
                String[] splitSX = str4.split(",");
                //封装学生对象存数组
                stus.add(new Student(splitSX[0], splitSX[1], splitSX[2], splitSX[3]));
            }
            br.close();
        } catch (Exception e) {
            System.out.println("读取数据异常");
        }
    }

    //反序列化流读取本地文件
    public static void load05() {
        try {
            //1. 创建一个反序列化流对象
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("server\\stu.txt"));
            //2. 读集合
            stus = (ArrayList<Student>) ois.readObject();

            //3. 关流
            ois.close();
        } catch (Exception e) {
            System.out.println("反序列化读取异常");
        }

    }


    //字节输出流写入本地文件
    public void reSave01() {
        try {
            //创建一个字节输出流对象

            FileOutputStream xie = new FileOutputStream("server\\stu.txt");

            //基于输出流对象将集合中的数据写出到文件
            //先遍历集合
            for (int i = 0; i < stus.size(); i++) {
                //拿到每一个学生对象信息
                Student stu = stus.get(i);
                //通过输出流将当前对象信息写出到文件
                xie.write(stu.toString().getBytes());
                //输出换行
                xie.write(System.lineSeparator().getBytes());
            }

            xie.close();
        } catch (Exception e) {
            System.out.println("字节输出流");
        }
    }

    //字节缓冲输出流写入本地文件
    public void reSave02() {
        try {
            //创建字节缓冲输出流对象
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("server\\stu.txt"));
            //基于缓冲字节输出流对象将集合中的数据写出到文件
            for (int i = 0; i < stus.size(); i++) {
                //拿到每一个学生对象信息
                Student stu = stus.get(i);
                //通过字节缓冲输出流将当前对象信息写出到文件
                bos.write(stu.toString().getBytes());
                //写一行换一行
                bos.write(System.lineSeparator().getBytes());
                //关流
                bos.close();
            }
        } catch (IOException e) {
            System.out.println("字节缓冲输出流写入异常");
        }
    }

    //字符输出流写入本地文件
    public void reSave03() {
        try {
            //创建字符输出流对象
            FileWriter fw = new FileWriter("server\\stu.txt");
            // 基于字符输出流对象将集合中的数据写出到文件
            for (int i = 0; i < stus.size(); i++) {
                Student stu = stus.get(i);
                //通过字符输出流将当前对象信息写出到文件
                fw.write(stu + "\r\n");
                fw.flush();
            }
        } catch (IOException e) {
            System.out.println("字符输出流写入异常");
        }

    }

    //字符缓冲输出流写入本地文件
    public void reSave04() {
        try {
            //创建对象
            BufferedWriter bw = new BufferedWriter(new FileWriter("server\\stu.txt"));
            //遍历集合
            for (int i = 0; i < stus.size(); i++) {
                //拿到每一位学生对象
                Student stu = stus.get(i);
                //通过字符缓冲输出流将当前对象信息写出到文件
                bw.write(stu + System.lineSeparator());
                bw.flush();
            }
            bw.close();
        } catch (Exception e) {
            System.out.println("字符缓冲输出流写入异常");
        }


    }

    //序列化流写入本地文件
    public void reSave05() {
        try {
            //创建序列化流
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("server\\stu.txt"));
            //将集合序列化出去
            oos.writeObject(stus);
            //关流
            oos.close();
        } catch (IOException e) {
            System.out.println("序列化流写入异常");
        }

    }


    //库管的登录功能
    public Properties finAllUsers() {
        //想要登录先看本地有那些管理人员资料
        Properties prop = new Properties();
        try {
            prop.load(new FileReader("server\\manager.txt"));
        } catch (Exception e) {
            System.out.println("当前登录入口读取本地异常");
        }
        return prop;
    }


}
